package com.xiangge.homework;

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

public class Test2 {
    public static void main(String[] args) {
        int x = 2;
        int y = (x++)/3;
        System.out.println(y);
    }

    /*1.创建一个测试类,
	2.定义两个方法分别统计出5位数的回文数个数和7位数的回文数个数
	3.在主方法中分别调用者两个方法 计算出相差的个数*/
    public static void main6(String[] args) {
        // 回文数是将一个数反转后还等于它本身的数 例如：12321 --->回文数12321
        int count = fivePalindrome();
        System.out.println("五位数中的回文数有" + count + "个");
    }
    public static int fivePalindrome(){
        // 要找到五位数内的所有回文数，那就使用一个统计，然后比较每一个五位数
        // 五位数[10000,99999]范围
        int count = 0;
        for (int i = 10000; i < 100000; i++) {
            // 要判断是不是回文数，需要多次的判断，不知道判断次数再使用个while循环
            // 循环的条件i!=0是循环体中最后取余，i=0时结束
            // 再定义一个变量用来代表循环数i，避免i在while循环中被改变
            int x = i;
            // 定义一个临时变量来存储反转数
            int numFan = 0;
            while (x != 0){
                // 判断回文数首先将数余除以10，得到最后一位数并保存,定义一个int变量num保存
                int num = x % 10;
                // 每余除以10后，就将i给除以10，去掉最后一位，这样就能得到所有位上的数
                x = x / 10;
                // 最后将每次得到的最后一位乘以10，不断相加，就能得到一个与原来的数完全相反的数
                numFan = numFan * 10 + num;
            }
            // 判断是不是回文数
            if (numFan == i){
                count++;
            }
        }
        return count;
    }

    /*   1.键盘录入一个整数(正数或者负数都可以,但是符号位不算有效的数字位)
         2.定义一个方法,该方法的功能是计算该数字是几位数字,并将位数返回
         3.在main方法中打印该数字是几位数
         4.演示格式如下:
             (1)演示一:
                 请输入一个整数:1234
                 控制台输出:1234是4位数字
             (2)演示二:
                 请输入一个整数:-34567
                 控制台输出:-34567是5位数字*/
    public static void main5(String[] args) {
        // 键盘录入整数，想要在控制台输出录入整数的位数,那就对输入的整数进行除法
        // 让录入的数不断除以10，int类型的变量只会保存整数位，这样就可以去掉最后一位
        // 再统计次数，那么最后除10的次数就是输入的整数的位数
        System.out.println("请输入一个整数：");
        int num = new Scanner(System.in).nextInt();
        // 调用方法
        int count = countNum(num);
        // 控制台输出输入数字和数字的位数
        System.out.println("用户输入的数为：" + num + "\n" + "用户输入数字的位数是：" + count + "位");
    }
    public static int countNum(int num){
        int count = 0;
        // 0是一种特殊情况，因为0不能作为除数，但却也是整数，所以当输入为0时，直接输出
        if (num == 0){
            System.out.println("用户输入的数为：" + 0 + "\n" + "用户输入数字的位数是：" + 1 + "位");
            return count;
        }
        // 不知道用户会输入多大的整数，所以使用while循环
        while (num != 0){
            num = num / 10;
            count++;
        }
        return count;
    }

    /*定义一个方法copyOfRange(int[] arr,int from, int to),
    功能:将数组arr中从索引from(包含from)开始到索引to结束(不包含to)的元素复制到新数组中,
    并将新数组返回*/
    public static int[] copyOfRange(int[] arr,int from, int to){
        // 有选择范围的将元素放入新数组中，要创建新数组，也要判断指针成立的条件
        // 1.起始指针不能小于终点指针 2.起始指针不能小于索引0 3.终点指针不能超出数组索引arr.length-1
        if (from > to || from < 0 || to > arr.length-1){
            System.err.println("取值范围错误");
            return arr;
        }
        // 创建新数组用来存放取得的元素，数组的长度那就满足to-from,因为不包含to，所以不必加一
        int[] newArr = new int[to - from];
        // 需要定义新数组的索引，用来在arr数组遍历赋值时提供位置
        int index = 0;
        // 要修改数组中的元素，需要先将数组进行遍历
        // 可以不做判断，直接在for循环的条件中将遍历范围改为指针起止，即[from,to]
        for (int i = from; i < to; i++) {
            // arr数组的取值从设定的范围开始，newArr数组的赋值则从第一位开始顺位赋值
            newArr[index] = arr[i];
            // 所以索引index要不断累加，因为遍历的上限就是创建的新数组的上限，所以index在这里不需要设置增长范围
            index++;
            /*这里也可以合并成一句
            arr[i] = newArr[index++]*/
        }
        // 返回新数组
        return newArr;
    }
    /*定义一个方法copyOf(int[] arr, int newLength),
    功能:将数组arr中的newLength个元素拷贝到新数组中,并将新数组返回,从索引为0开始*/
    public static int[] copyOf(int[] arr, int newLength){
        // 要拿取数组arr中的newLength个元素，建立新数组存放,数组的长度由拿取的元素来决定
        int[] newArr = new int[newLength];
        // 将拿取的元素放入新数组中，先将数组进行遍历
        for (int i = 0; i < newArr.length; i++) {
            // 因为新数组的长度就是拿取的元素个数newArr.length == newLength
            // 所以这里遍历新数组后可以直接让新数组的索引0到索引newLength-1,赋值arr数组中的同位
            newArr[i] = arr[i];
        }
        return newArr;
    }
    /*定义一个方法fill(int[] arr,int fromIndex,int toIndex,int value),
    功能:将数组arr中的元素从索引fromIndex开始到toIndex(不包含toIndex)对应的值改为value*/
    public static void fill(int[] arr,int fromIndex,int toIndex,int value){
        // 想要修改数组中选中范围的元素，那就存在指针的限制条件
        // 1.起始指针不能小于终点指针 2.起始指针不能小于索引0 3.终点指针不能超出数组索引arr.length-1
        if (fromIndex > toIndex || fromIndex < 0 || toIndex > arr.length-1){
            System.err.println("范围选取不合规");
            return;
        }
        // 要修改数组中的元素，需要先将数组进行遍历
        // 可以不做判断，直接在for循环的条件中将遍历范围改为指针起止，即[fromIndex,toIndex]
        for (int i = fromIndex; i <= toIndex; i++) {
            arr[i] = value;
        }
    }
    /*定义一个方法fill(int[] arr,int value),
    功能:将数组arr中的所有元素的值改为value*/
    public static void fill(int[] arr,int value){
        // 要将数组中的每一个元素改为value，那就要遍历一次数组
        for (int i = 0; i < arr.length; i++) {
            // 让数组arr的每一个索引对应的元素改为value
            arr[i] = value;
        }
    }
    /*定义一个方法equals(int[] arr1,int[] arr2),
    功能:比较两个数组是否相等(长度和内容均相等则认为两个数组是相同的)*/
    public static void equals(int[] arr1,int[] arr2){
        // 判断两个数组是否相同分别看两个数组 1.长度是否相等 2.元素是否相同
        if (arr1.length != arr2.length){
            System.err.println("两个数组不同");
            return;
        }
        // 如果两个数组长度相同，那么就进行数组内容的比较
        // 遍历两个数组中的其中一个数组，然后将同一位置的元素进行比较
        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] != arr2[i]){
                System.out.println("两个数组不同");
                return;
            }
        }
        System.out.println("两个数组相同");
    }

    /*主方法中给定数组int[] arr= {10,20,30,40,50,60};
    这个数组没有重复元素.定义一个方法可以接受这个给定的数组并返回这个数组中最大元素值的索引值。*/
    public static void main3(String[] args) {
        // 定义一个数组
        int[] arr= {10,20,30,40,50,60};
        int maxIndex = getMaxIndex(arr);
        System.out.println("数组中最大值的索引值是：" + maxIndex);
    }
    private static int getMaxIndex(int[] arr) {
        // 创建一个有参有返回值的方法

        // 要实现得到数组中最大元素值的索引值，要遍历数组然后进行比较
        // 首先假设数组中第一个元素就是最大值，那么他的索引就是0
        int max = arr[0];
        int maxIndex = 0;
        // 遍历数组，然后进行比较。因为已经假设第一个元素为最大值了，所以只需要从第二个元素开始遍历比较即可
        for (int i = 1; i < arr.length; i++) {
            // 进行元素大小比较
            if (max < arr[i]){
                max = arr[i];
                maxIndex = i;
            }
        }
        // 得到返回值返回最大值的索引值
        return maxIndex;
    }

    /*将数字1-10保存到一个长度为10的一维数组中.
    定义一个新数组,长度为3,取出原来数组中随机三个元素(不考虑是否重复)
    1.给新数组的元素赋值
    2.求新数组所有元素的和*/
    public static void main2(String[] args) {
        // 首先定义一个数组用来存放数字1-10
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        // 再定义一个长度为3的新数组
        int[] newArr = new int[3];
        // 将拿取到的元素放入新数组中，对新数组进行遍历
        for (int i = 0; i < newArr.length; i++) {
            // 要随机取出原数组中的三个数，那就要定义index来代表拿取元素的位置
            // 同时用Random方法来随机生成范围在0-9的数，将其赋值给index作为取数的索引
            int index = new Random().nextInt(10);
            newArr[i] = arr[index];
        }
        // 使用Array工具查看新数组
        System.out.println(Arrays.toString(newArr));
        // 求出新数组所有元素的和
        int sum = 0;
        for (int i = 0; i < newArr.length; i++) {
            // 遍历新数组后累加求和
            sum = sum + newArr[i];
        }
        System.out.println("新数组所有元素的和为：" + sum);
    }

    /*键盘录入一个整数，创建一个该长度的数组，
    为每一个元素赋值为1-10的随机整数，
    最后打印数组中所有值大于5且为偶数的元素.*/
    public static void main1(String[] args) {
        // 创建一个数组，数组的长度由键盘录入
        System.out.println("请输入一个整数：");
        int[] arr = new int[new Scanner(System.in).nextInt()];
        // 数组中的元素在[1,10]的范围里随机赋值
        // 首先要将数组遍历，再对每个元素进行随机赋值
        for (int i = 0; i < arr.length; i++) {
            // 使用Random方法随机生成范围数
            arr[i] = new Random().nextInt(10) + 1;
        }
        // 使用Arrays工具展示数组
        System.out.println(Arrays.toString(arr));
        // 打印数组当中所有大于5且为偶数的元素
        // 再次遍历数组，在数组内部进行判断
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > 5 && arr[i] % 2 == 0) {
                System.out.print(arr[i] + "\t");
            }
        }
    }
}
